The Business Master (3rd Edition)/The Business Master (3rd Edition).iso/files/business/stata2/stat.kit

Text File | 1988-08-16 | 18.4 KB | 728 lines

set output error

display _new in blue /*
*/ "Loading Stat.Kit Release 2.0  Demonstration Version" _n /*
*/ "Copyright (c) 1987-1988 by ==C=R=C==.  All rights reserved."




/*
  User's wishing to edit Stat.Kit please see comments at end of this file.


    utility routines used by various programs:
*/

capture program drop _nmusig2
program define _nmusig2
    capture {
        sum %_1 %_5 %_6
        gen int %_2 = _result(1) in l
        gen double %_3 = _result(3) in l
        gen double %_4 = _result(4) in l
        exit
    }
    capture drop %_2
    capture drop %_3
    capture drop %_4
    BREAK
end

/*
    top level programs
*/

capture program drop ttest
program define ttest
    if "%_*"=="" {
        di in blue "-> ttest varname = #"
        di in blue "-> ttest varname = varname[, equal unequal paired]"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _exp "req noprefix"
    mac def _in "opt"
    mac def _if "opt"
    mac def _options "Equal Unequal Paired"
    parse "%_*"
    capture conf numb %_exp
    if _rc==0 {
        if "%_equal`%_unequal`%_paired"~="" {
            di in red /*
            */ "options not allowed when testing against constant."
            exit
        }
        _ttmean %_varlist %_exp "%_if" "%_in"
        exit
    }
    conf var %_exp
    parse "%_equal %_unequal %_paired", parse(" ")
    if "%_2"!="" {
        di in red "%_* ?"
        exit
    }
    if "%_unequal"!="" {
        _ttneq %_varlist %_exp "%_if" "%_in"
        exit
    }
    if "%_paired"!="" {
        _ttpair %_varlist %_exp "%_if" "%_in"
        exit
    }
    _tteq %_varlist %_exp "%_if" "%_in"
end


capture program drop _tteq
program define _tteq
    capture {
        _nmusig2 %_1 _N1 _M1 _V1 "%_3" "%_4"
        _nmusig2 %_2 _N2 _M2 _V2 "%_3" "%_4"
        #delimit ;
        mac def _tstat=(_M1-_M2) / (
               sqrt(((_N1-1)*_V1+(_N2-1)*_V2)/(_N1+_N2-2)) *
               sqrt(1/_N1+1/_N2)
               ) in l ;
        noisily sum %_1 %_2 %_3 %_4 ;
        di _n in g
       "Test: means of %_1 and %_2 are equal (assuming equal variances)"
            _n ;
        di in g " Difference = " in y _M1[_N]-_M2[_N] ;
        di in g "t-statistic = " in y %5.2f %_tstat in g " with "
           in y _N1[_N]+_N2[_N]-2 in g " d.f." ;
        di in gr " Prob > |t| = " in ye %6.4f
           max(tprob(_N1[_N]+_N2[_N]-2,%_tstat),.0001) ;
        #delimit cr
    }
    if _rc {
        di in red "--Break--"
    }
    capture drop _N1 _M1 _V1
    capture drop _N2 _M2 _V2
end

capture program drop _ttmean
program define _ttmean
    sum %_1 %_3 %_4
    mac def _ts=(_result(3)-(%_2))*sqrt(_result(1))/sqrt(_result(4)) in l
    di _n _sk(9) in gr "Test: mean of %_1 = " in ye "%_2"
    #delimit ;
    di _sk(15) in gr "t-statistic = " in y %5.2f %_ts in gr " with "
        in y _result(1)-1 in g " d.f." ;
    #delimit cr
    di _sk(15) in gr "Prob > |t|  = ",in ye %6.4f tprob(_result(1)-1,%_ts)
end

capture program drop _ttneq
program define _ttneq
    capture {
        _nmusig2 %_1 _N1 _M1 _V1 "%_3" "%_4"
        _nmusig2 %_2 _N2 _M2 _V2 "%_3" "%_4"
        mac def _tstat=(_M1-_M2)/sqrt((_V1/_N1)+(_V2/_N2)) in l
        #delimit ;
        mac def _dof=int((((_V1/_N1)+(_V2/_N2))^2)/(
            ((_V1/_N1)^2)/(_N1+1)+((_V2/_N2)^2)/(_N2+1)
            )-1.5) in l ;
        noisily sum %_1 %_2 %_3 %_4;
        di _n in gr
         "Test: means of %_1 and %_2 are equal (unequal variances)" _n;
        di in gr " Difference = " in ye _M1[_N]-_M2[_N] ;
        di in gr "t-statistic = " in ye %5.2f %_tstat in gr " with "
           in ye %_dof in gr " d.f." ;
        di in gr " Prob > |t| = "
           in ye %6.4f max(tprob(%_dof,%_tstat),.0001) ;
        #delimit cr
    }
    if _rc {
        di in red "--Break--"
    }
    capture drop _N1 _M1 _V1
    capture drop _N2 _M2 _V2
end


capture program drop _ttpair
program define _ttpair
    capture {
        gen double _DIFF=%_1-%_2
        _nmusig2 _DIFF _CNT _MEAN _VAR
        mac def _tstat=(_MEAN*sqrt(_CNT))/sqrt(_VAR) in l
        noisily sum %_1 %_2 if %_1~=. & %_2~=.
        #delimit ;
        di _n in gr
          "Test: means of %_1 and %_2 are equal (paired observations)" _n;
        di in gr " Difference = " in ye _MEAN[_N] ;
        di in gr "t-statistic = " in ye %5.2f %_tstat in gr " with "
           in ye _CNT[_N]-1 in gr " d.f." ;
        di in gr " Prob > |t| = "
           in ye %6.4f max(tprob(_CNT[_N]-1,%_tstat),.0001) ;
        #delimit cr
    }
    if _rc {
        di in red "--Break--"
    }
    capture drop _DIFF
    capture drop _CNT _MEAN _VAR
end


capture program drop teststd
program define teststd
    if "%_*"=="" {
        di in blu "-> teststd varname = {varname | number}"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _exp "req noprefix"
    mac def _in "opt"
    mac def _if "opt"
    parse "%_*"
    capture conf numb %_exp
    if _rc==0 {
        _tscon %_varlist %_exp "%_if" "%_in"
        exit
    }
    conf var %_exp
    _tsvar %_varlist %_exp "%_if" "%_in"
end

capture program drop _tscon
program define _tscon
    sum %_1 %_3 %_4
    quietly {
        mac def _c2=(_result(1)-1)*(_result(4)/((%_2)^2))
        mac def _p = max(chiprob(_result(1)-1,(%_c2)+(1e-20)),.0001)
        di _n in gr "Test: standard deviation of %_1 = %_2`:" _n
        #delimit ;
        di in gr " chi-square = " in ye %5.2f %_c2 in gr " with "
           in ye _result(1)-1 in gr " d.f." ;
        di in gr "probability = " in ye %6.4f min(%_p,1-(%_p))
           in gr " (one-tailed test)" ;
        #delimit cr
    }
end

capture program drop _tsvar
program define _tsvar
    sum %_1 %_2 %_3 %_4
    capture {
        _nmusig2 %_1 _N1 _M1 _V1 "%_3" "%_4"
        _nmusig2 %_2 _N2 _M2 _V2 "%_3" "%_4"
        mac def _f=_V1/_V2 in l
        if _V1[_N]<_V2[_N] {
            mac def _f=_V2/_V1 in l
            mac def _h=_N1 in l
            replace _N1=_N2 in l
            replace _N2=%_h in l
        }
        di in gr _n "Test: variances of %_1 and %_2 are equal" _n
        #delimit ;
        di in gr "F-statistic = " in ye %6.3f %_f in gr " with ("
           in ye _N1[_N]-1 in gr "," in ye _N2[_N]-1 in gr ") d.f.";
        di in gr "   Prob > F = "
           in ye %6.4f max(fprob(_N1[_N]-1,_N2[_N]-1,%_f),.0001) ;
        #delimit cr
    }
    if _rc {
        di in red "--Break--"
    }
    capture drop _N1 _M1 _V1
    capture drop _N2 _M2 _V2
end

capture program drop genstd
program define genstd
    if "%_*"=="" {
        di in bl "-> genstd newvar = exp [if] [in], mean(#) std(#)"
        exit
    }
    mac def _varlist "req new max(1)"
    mac def _exp "req noprefix"
    mac def _options "Mean(real 0) Std(real 1)"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    quietly {
        replace %_varlist = %_exp %_in %_if
        quietly sum %_varlist
        #delimit ;
        replace %_varlist =
             ((%_varlist-_result(3))/sqrt(_result(4)))*(%_std)
             + (%_mean) ;
        #delimit cr
        label var %_varlist "Standardized values of %_exp"
    }
end

capture program drop spearman
program define spearman
    if "%_*"=="" {
        di in blue "-> spearman var1 var2 [if] [in]"
        exit
    }
    mac def _varlist "req ex min(2) max(2)"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    parse "%_varlist", parse(" ")
    capture {
        genrank _SP1 = %_1 %_if %_in
        conf var _SP1
        genrank _SP2 = %_2 %_if %_in
        conf var _SP2
    }
    if _rc==0 {
        ren %_1 _SP3
        ren %_2 _SP4
        ren _SP1 %_1
        ren _SP2 %_2
        capture noisily {
            di _n in green "Spearman Rank Correlation"
            corr %_1 %_2
        }
        drop %_1 %_2
        ren _SP3 %_1
        ren _SP4 %_2
    }
end

capture program drop signtest
program define signtest
    if "%_*"=="" {
        di in blue "-> signtest var1 = exp [if] [in]"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _exp "req noprefix"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    set out e
    di _n in gr "Test: Equality of medians (Matched Sample Sign Test)" _n
    capture {
        gen int _Dif=sign((%_varlist)-(%_exp)) %_if %_in
        count if _Dif==0
        mac def _zer = _result(1)
        count if _Dif==1
        mac def _pos = _result(1)+(%_zer)/2
        count if _Dif==-1
        mac def _neg = _result(1)+(%_zer)/2
        mac def _z=((%_pos)-(%_neg))/sqrt((%_pos)+(%_neg))
        drop _Dif
    }
    if _rc==1 {
        di in red "--Break--"
        capture drop _Dif
        exit
    }
    di in gr "Result of %_varlist - (%_exp) %_if %_in"
    di in gr " -------------------"
    di in gr " Positive " in ye %10.0g %_pos
    di in gr " Negative " in ye %10.0g %_neg
    di in gr " -------------------"
    di in gr " Total    " in ye %10.0g %_pos+%_neg _n
    di in gr "Exact 5%` test:  Reject if smaller frequency from table above"
    #delimit ;
    di in gr " is less than " in ye
       int((%_pos+%_neg-1)/2-.98*sqrt(%_pos+%_neg+1)+.5)," (+/- 1)" _n;
    di in gr "Normal Approximation:";
    di in gr " z-statistic " in ye %6.3f %_z ;
    di in gr " Prob > |z|  " in ye %6.4f max(normprob(-abs(%_z))*2,.0001) ;
    #delimit cr
end

capture program drop signrank
program define signrank
    if "%_*"=="" {
        di in blue "-> signrank var = exp [if] [in]"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _exp "req noprefix"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    capture {
        genrank _R=abs(%_varlist-(%_exp)) %_if %_in
        gen _R0=sum(cond(sign(%_varlist-(%_exp))==0,_R,0))
        gen _Rp=sum(cond(sign(%_varlist-(%_exp))==1,_R,0))+_R0/2
        gen _Rn=sum(cond(sign(%_varlist-(%_exp))==-1,_R,0))+_R0/2
        gen int _C=sum(_R~=.)
        drop _R
        #delimit ;
        di _n in gr
        "Test:  Equality of distributions (Wilcoxon Signed-Ranks)" _n ;
        di in gr "Result of %_varlist - (%_exp) %_if %_in" _n
             " Sum of Positive Ranks = " in ye _Rp[_N] _n
           in gr " Sum of Negative Ranks = " in ye =_Rn[_N] _n ;
        drop _R0 _Rn ;
        mac def _z=(_Rp-(_C*(_C+1)/4))/sqrt(_C*(_C+1)*(2*_C+1)/24) in l;
        di in gr " z-statistic " in ye %6.2f %_z _n
           in gr " Prob > |z|  " in ye
           %8.4f max(normprob(-abs(%_z))*2,.0001);
        drop _Rp _C;
        #delimit cr
    }
    if _rc == 1 {
        di in red "--Break--"
        capture drop _R
        capture drop _R
        capture drop _R0
        capture drop _Rn
        capture drop _Rp
        capture drop _C
    }
end

capture program drop regdw
program define regdw
    if "%_*"=="" {
        di in bl /*
         */    "-> regdw lhsvar rhsvar rhsvar ... [, regress_options ] "
        exit
    }
    reg %_*
    quietly {
        predict double _RES, res
        gen double _DW=sum((_RES-_RES[_n-1])^2)/sum(_RES*_RES)
        di in gr "Durbin Watson Statistic = " in ye _DW[_N]
        drop _DW _RES
    }
end

capture program drop ranksum
program define ranksum
    di in blue "not available in demonstration version"
end

capture program drop genrank
program define genrank
    if "%_*"=="" {
        di in bl "-> genrank varname = exp [if] [in]"
        exit
    }
    mac def _varlist "req new max(1)"
    mac def _exp "req nopre"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    capture {
        gen _GRV = %_exp %_if %_in
        sort _GRV
        gen int _GRr = cond(_GRV==_GRV[_n-1],_GRr[_n-1],_n) if _GRV~=.
        by _GRV: replace %_varlist = _GRr+(_N-1)/2
        drop _GRV _GRr
        label var %_varlist "Rank of %_exp"
    }
    if _rc==1 {
        di in red "--Break--"
        capture drop _GRV
        capture drop _GRr
        capture drop %_varlist
    }
end


capture program drop means
program define means
    mac def _varlist "opt ex"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    parse "%_varlist", parse(" ")
    #delimit ;
    di _new in gr _col(10) "|" _col(17) "Arithmetic" _col(35) "Geometric"
         _col(54) "Harmonic" ;
    di in gr _col(10) "|" _col(12) _dup(3) "     Mean   Obs   " ;
    di in gr _dup(9) "-" "+" _dup(52) "-" ;
    #delimit cr
    quietly {
        while "%_1"~="" {
            capture {
                gen double _VAR = %_1 %_if %_in
                quietly sum _VAR
                mac def _acnt = _result(1)
                mac def _amea = _result(3)
                gen double _VAR2=log(_VAR)
                summarize _VAR2
                mac def _gcnt = _result(1)
                mac def _gmea = exp(_result(3))
                replace _VAR2 = sum(cond(_VAR>0,1/_VAR,0))
                #delimit ;
                di in gr "%_1" _col(10) "|",in ye
                   %9.0g %_amea,%5.0f %_acnt,
                   "  " %9.0g %_gmea,%5.0f %_gcnt,
                   "  " %9.0g %_gcnt/_VAR2[_N],%5.0f %_gcnt ;
                #delimit cr
            }
            if _rc {
                di in red "--Break--"
                capture drop _VAR
                capture drop _VAR2
                exit
            }
            drop _VAR _VAR2
            mac shift
        }
    }
end

capture program drop kwallis
program define kwallis
    if "%_*"=="" {
        di in bl "-> kwallis varname [if] [in], by(grouping_var_name)"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _options "BY(string)"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    if "%_by"=="" {
        di in red "You must specify the grouping variable"
        kwallis
        exit
    }
    confirm var %_by
    capture {
        genrank _RankSum = %_varlist %_if %_in  /* ranks right now */
        gen int _Obs=1 if _RankSum~=.
        sort %_by
        by %_by: replace _RankSum=cond(_n==_N,sum(_RankSum),.)
        by %_by: replace _Obs=cond(_n==_N,sum(_Obs),.)
        by %_by: gen int _Grp=1 if _n==_N & _Obs>0
        replace _Grp=sum(_Grp)
        di _n in gr /*
        */ "Test: Equality of populations (Kruskal-Wallis Test)"
        format _RankSum %9.2f
        noisily l %_by _Obs _RankSum if _Obs~=. & _Obs~=0, noobs
        replace _RankSum=sum(_RankSum*_RankSum/_Obs)
        replace _Obs=sum(_Obs)
        mac def _K=12/(_Obs*(_Obs+1))*_RankSum-3*(_Obs+1) in l
        #delimit ;
        di _new in gr " chi-square = " in ye %9.3f %_K
            in gr " with " in ye _Grp[_N]-1 in gr " d.f." ;
        di in gr "probability = " in ye
            %10.4f max(chiprob(_Grp[_N]-1,%_K+(1e-20)),.0001) ;
        #delimit cr
        drop _Obs _RankSum _Grp
    }
    if _rc==1 {
        di in red "--Break--"
        capture drop _Obs
        capture drop _RankSum
        capture drop _Grp
    }
end

capture program drop ksmirnov
program define ksmirnov
    if "%_*"=="" {
        di in blue "->ksmirnov var = exp [if] [in] [, onesamp]"
        exit
    }
    mac def _varlist "req ex max(1)"
    mac def _exp "req noprefix"
    mac def _if "opt"
    mac def _in "opt"
    mac def _options "Onesamp"
    parse "%_*"
    parse "%_varlist", parse(" ")
    di _n in gr "Test: Equality of Distribution Functions (Kolmogorov-Smirnov)" _n
    capture {
        gen _G1 = (%_1!=.) %_if %_in
        replace _G1 = (_G1==1)
        gen _v = %_exp %_if %_in
        if "%_onesamp"=="" {
            gen _G2 = 1 if _v!=.
            replace _v = %_1 if _v==.
            sort _v
            replace _G1 = sum(_G1)
            mac def _m = _G1[_N]
            replace _G1 = _G1 / %_m
            replace _G2 = sum(_G2)
            mac def _k = _G2[_N]
            replace _G2 = _G2 / %_k
            replace _G1 = _G1 - _G2
            by _v: replace _G1 = _G1[_N]
        }
        if "%_onesamp"~="" {
            sort %_1
            replace _G1 = sum(_G1)
            mac def _m = _G1[_N]
            replace _G1 = _G1 / %_m
            replace _G1 = _G1 - _v
            mac def _k = 10e6
        }
        summarize _G1
        mac def _Dm = _result(5)
        mac def _Dp = _result(6)
        if "%_onesamp"~="" {
            mac def _Dm = %_Dm - 1/%_m
            }
        mac def _D = max(-%_Dm,%_Dp)
        mac def _A = %_m*%_k/(%_m+%_k)
        mac def _Pm = exp(-2*%_A*%_Dm^2)
        mac def _Pp = exp(-2*%_A*%_Dp^2)
        mac def _Z2 = %_A*(%_D^2)
        mac def _P = exp(-2*%_Z2) - exp(-8*%_Z2) + exp(-18*%_Z2) /*
                */ - exp(-32*%_Z2) + exp(-50*%_Z2)
        mac def _P = min(2*%_P, 1)
        mac def _Pc = %_P
        if %_P<1 {
            mac def _Pz = invnorm(%_P)+1.04/min(%_m,%_k) /*
                 */ +2.09/max(%_m,%_k)-1.35/sqrt(%_A)
            mac def _Pc = normprob(%_Pz)
        }
        drop _G1 _G2 _v
    }
    if _rc==1 {
        di in red "--Break--"
        capture drop _G1
        capture drop _G2
        capture drop _v
        exit
    }
    mac def _exp = substr("%_exp",1,8)
    di in gr " Smaller group       D      P-value  Corrected"
    di in gr " " _dup(45) "-"
    di in gr " %_1:" _col(20) in ye %8.4f %_Dp %8.3f %_Pp
    di in gr " %_exp:" _col(20) in ye %8.4f %_Dm %8.3f %_Pm
    di in gr " Combined K-S:" _col(20) in ye %8.4f %_D  %8.3f %_P %8.3f %_Pc
end



capture program drop gprobit
program define gprobit
    if "%_*"=="" {
        di in bl "-> gprobit successes population rhs-vars... [if] [in]"
        exit
    }
    mac def _varlist "req ex"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    parse "%_varlist", parse(" ")
    quietly {
        gen long _S=%_1 if %_1>=0
        gen long _P=%_2 if %_2>=0 & %_1<=%_2
        gen double _PROBIT=invnorm(_S/_P) %_if %_in
    }
    di _n in gr "Minimum chi-square probit estimates for grouped data:"
    mac shift
    mac shift
    reg _PROBIT %_* =(exp(-_PROBIT^2)/(2*_pi))*(_P/((_S/_P)*((_P-_S)/_P)))
    drop _PROBIT _S _P
end

capture program drop glogit
program define glogit
    if "%_*"=="" {
        di in bl "-> glogit successes population rhs-vars... [if] [in]"
        exit
    }
    mac def _varlist "req ex min(2)"
    mac def _if "opt"
    mac def _in "opt"
    parse "%_*"
    parse "%_varlist", parse(" ")
    quietly {
        gen long _S=%_1 if %_1>=0
        gen long _F=%_2-%_1 if %_2>=0 & %_2>%_1
        gen double _LOGIT=log(_S/_F) %_if %_in
    }
    di _n in gr "Minimum chi-square logit estimates for grouped data:"
    mac shift
    mac shift
    reg _LOGIT %_* =(_S*_F)/(_S+_F)
    drop _LOGIT _S _F
end

capture program drop dbeta
program define dbeta
    if "%_3"=="" {
        di in bl "-> dbeta lhs rhs other-rhs [if] [in], gen(newvar)"
        exit
    }
    mac def _varlist "req ex min(2)"
    mac def _if "opt"
    mac def _in "opt"
    mac def _options "Generate(string)"
    parse "%_*"
    if "%_generat"=="" {
        dbeta
        exit
    }
    conf new var %_generat
    parse "%_varlist", parse(" ")
    mac def _lhs %_1
    mac shift
    quietly {
        reg %_* %_if %_in
        pred double _RES %_if %_in, res
        noisily reg %_lhs %_* %_if %_in
        pred double _HAT %_if %_in, hat
        pred double _RSTU %_if %_in, rstud
        gen double _SRES=sum(_RES^2)
        gen %_generat=_RSTU*_RES/sqrt((1-_HAT)*_SRES[_N])
    }
    drop _RES _HAT _RSTU _SRES
    label var %_generat "DF-Betas for %_1"
    di _n in bl "(%_generat now contains DF-Betas for %_1)"
end


di
di in gr "The following new commands are now available:"
di "   dbeta          glogit         kwallis        regdw          spearman"
di "   genrank        gprobit        means          signrank       teststd"
di "   genstd         ksmirnov       ranksum        signtest       ttest"
di _n in gr "See " in wh "help stat.kit" in gr "."
exit

di "   xxxxxxxxxxxx   xxxxxxxxxxxx   xxxxxxxxxxxx   xxxxxxxxxxxx   xxxxxxxxxxxx"

Notes to User's wishing to edit this file:

These comments are placed at the end of the file, after the exit, so that
Stata does not have to read through them every time the user types "run
Stat.Kit"

Feel free to edit this file and delete programs in which you have no interest.
Before editing this file, however, make sure the the original is BACKED UP.
Please do not remove the copyright notice at the top of this file.

If you do edit the file, you should add a display command at the top of this
file indicating that you have edited the file.  You should change the display
just above these comments that lists the new commands now available.

All utility programs start with an underscore '_'.

Some programs use other programs in achieving the desired result.  Review the
table below carefully before deleting programs.

        Program         Requires
        --------------------------
        dbeta
        genrank
        genstd
        glogit
        gprobit
        ksmirnov
        kwallis         genrank
        means
        ranksum         genrank
        regdw
        signrank        genrank
        signtest
        spearman        genrank
        teststd        _nmusig2 _tscon _tsvar
        ttest          _nmusig2 _tteq _ttneq _ttpair _ttmean

For instance, if you deleted the genrank program, you would break kwallis,
ranksum, signrank, and spearman.

<end of Stat.Kit>